package cn.ztr.ymcc.service.impl;

import cn.ztr.ymcc.domain.CourseType;
import cn.ztr.ymcc.mapper.CourseTypeMapper;
import cn.ztr.ymcc.query.CourseTypeQuery;
import cn.ztr.ymcc.result.JsonResult;
import cn.ztr.ymcc.service.ICourseTypeService;
import cn.ztr.ymcc.util.AssertUtil;
import cn.ztr.ymcc.vo.CrumbsVo;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * <p>
 * 课程目录 服务实现类
 * </p>
 *
 * @author ztr
 * @since 2023-02-27
 */
@Service
public class CourseTypeServiceImpl extends ServiceImpl<CourseTypeMapper, CourseType> implements ICourseTypeService {
    private static final String COURSE_TYPE_TREE="course_type_tree";

    /**
     * 添加或修改课程类型
     * @param entity 实体对象
     * @return
     */
    @CacheEvict(cacheNames = COURSE_TYPE_TREE,key = "'ALL'")
    @Transactional
    @Override
    public boolean save(CourseType entity) {
        if (entity.getPid()==null){
            entity.setPid(0l);
            baseMapper.insert(entity);
            return true;
        }
        baseMapper.insert(entity);
        //查询父级
        CourseType parent = baseMapper.selectOne(new QueryWrapper<CourseType>().eq("id", entity.getPid()));
        entity.setPath(parent.getPath()+"."+entity.getId());
        baseMapper.updateById(entity);
        return true;
    }

    /**
     * 查询课程类别树
     * @return
     */
    @Override
    @Cacheable(cacheNames = COURSE_TYPE_TREE,key = "'ALL'")
    public JsonResult treeData() {
        System.out.println("开始查询数据库.....................");
        return getTree();
    }

    /**
     * 带条件分页查询数据
     * @param
     * @return
     */
    @Override
    public JsonResult querylist(CourseTypeQuery query) {
        List<CourseType> querylist = baseMapper.querylist(query);
        Long total = baseMapper.querListTotal(query);
        Map<String,Object> map = new HashMap<>();
        map.put("rows",querylist);
        map.put("total",total);
        return JsonResult.me(map);
    }


    /**
     * 查询面包屑
     * @param id
     * @return
     */
    @Override
    public JsonResult loadCrumbs(Long id) {
        ArrayList<CrumbsVo> crumbsVos = new ArrayList<>();
        //1 根据id查询当前类别的信息
        CourseType courseType = baseMapper.selectById(id);

        //2 获取当前类型的层级路径
        String path = courseType.getPath();
        String[] paths = path.split("\\.");

        //3.1 循环路径,获得每一个循环的类型id
        for (String pathId : paths) {
            CrumbsVo crumbsVo = new CrumbsVo();
            //3.2 查询当前类型id的信息,并添加到crumbsVo中
            CourseType courseType1 = baseMapper.selectById(pathId);
            crumbsVo.setCurrent(courseType1);
            //3.2 查询当前类型id的兄弟类型
            List<CourseType> currentBrother = baseMapper.selectList(new QueryWrapper<CourseType>().eq("pid", courseType1.getPid()));
            //3.3 将兄弟类型放入集合
            crumbsVo.setBrother(currentBrother);
            crumbsVos.add(crumbsVo);
        }

        return JsonResult.me(crumbsVos);
    }

    private JsonResult getTree() {
        //1 获取所有课程类别
        List<CourseType> courseTypes = baseMapper.selectList(null);
        List<CourseType> first=new ArrayList<>();
        //2 把课程类别存入map
        Map<Long,CourseType> map = courseTypes.stream().collect(Collectors.toMap(item->item.getId(),item->item));
        //3 遍历课程类别
        for (CourseType courseType : courseTypes) {
            if (courseType.getPid()==0)
                //顶级父类,加入tree
                first.add(courseType);
            else
                //存在父级,加入父级中
                map.get(courseType.getPid()).getChildren().add(courseType);

        }
        return JsonResult.me(first);
    }

    /**
     * 根据id删除课程类型
     * @param id 主键ID
     * @return
     */
    @Override
    @CacheEvict(cacheNames = COURSE_TYPE_TREE,key = "'ALL'")
    public boolean removeById(Serializable id) {
        List<CourseType> courseTypes = baseMapper.selectList(new QueryWrapper<CourseType>().eq("pid", id));
        AssertUtil.isTrue(courseTypes==null||courseTypes.size()==0,"当前课程类型存在下级,无法删除");
        return super.removeById(id);
    }


}
